﻿
namespace ZJUDTS.Web
{
	using System;
	using System.Collections.Generic;
	using System.ComponentModel;
	using System.ComponentModel.DataAnnotations;
	using System.Data.Objects.DataClasses;
	using System.Linq;
	using System.ServiceModel.DomainServices.Hosting;
	using System.ServiceModel.DomainServices.Server;


	// MetadataTypeAttribute 将 AchievementMetadata 标识为类
	//，以携带 Achievement 类的其他元数据。
	[MetadataTypeAttribute(typeof(Achievement.AchievementMetadata))]
	public partial class Achievement
	{

		// 通过此类可将自定义特性附加到
		//Achievement 类的属性。
		//
		// 例如，下面的代码将 Xyz 属性标记为
		//必需属性并指定有效值的格式:
		//    [Required]
		//    [RegularExpression("[A-Z][A-Za-z0-9]*")]
		//    [StringLength(32)]
		//    public string Xyz { get; set; }
		internal sealed class AchievementMetadata
		{

			// 元数据类不会实例化。
			private AchievementMetadata()
			{
			}

			public string Description
			{
				get;
				set;
			}

			public int Id
			{
				get;
				set;
			}

			public string Name
			{
				get;
				set;
			}

			public string Title
			{
				get;
				set;
			}

			public EntityCollection<User> Users
			{
				get;
				set;
			}
		}
	}

	// MetadataTypeAttribute 将 CompositeMetadata 标识为类
	//，以携带 Composite 类的其他元数据。
	[MetadataTypeAttribute(typeof(Composite.CompositeMetadata))]
	public partial class Composite
	{

		// 通过此类可将自定义特性附加到
		//Composite 类的属性。
		//
		// 例如，下面的代码将 Xyz 属性标记为
		//必需属性并指定有效值的格式:
		//    [Required]
		//    [RegularExpression("[A-Z][A-Za-z0-9]*")]
		//    [StringLength(32)]
		//    public string Xyz { get; set; }
		internal sealed class CompositeMetadata
		{

			// 元数据类不会实例化。
			private CompositeMetadata()
			{
			}

			public int Id
			{
				get;
				set;
			}

			public EntityCollection<Item> Material
			{
				get;
				set;
			}

			public EntityCollection<Item> Products
			{
				get;
				set;
			}
		}
	}

	// MetadataTypeAttribute 将 EventMetadata 标识为类
	//，以携带 Event 类的其他元数据。
	[MetadataTypeAttribute(typeof(Event.EventMetadata))]
	public partial class Event
	{

		// 通过此类可将自定义特性附加到
		//Event 类的属性。
		//
		// 例如，下面的代码将 Xyz 属性标记为
		//必需属性并指定有效值的格式:
		//    [Required]
		//    [RegularExpression("[A-Z][A-Za-z0-9]*")]
		//    [StringLength(32)]
		//    public string Xyz { get; set; }
		internal sealed class EventMetadata
		{

			// 元数据类不会实例化。
			private EventMetadata()
			{
			}

			public int Id
			{
				get;
				set;
			}

			public EntityCollection<Location> Locations
			{
				get;
				set;
			}

			public string Name
			{
				get;
				set;
			}
		
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public Nullable<int> RewardExp
			{
				get;
				set;
			}

			public EntityCollection<Item> RewardItem
			{
				get;
				set;
			}

			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public Nullable<int> RewardMoney
			{
				get;
				set;
			}
		}
	}

	// MetadataTypeAttribute 将 ItemMetadata 标识为类
	//，以携带 Item 类的其他元数据。
	[MetadataTypeAttribute(typeof(Item.ItemMetadata))]
	public partial class Item
	{

		// 通过此类可将自定义特性附加到
		//Item 类的属性。
		//
		// 例如，下面的代码将 Xyz 属性标记为
		//必需属性并指定有效值的格式:
		//    [Required]
		//    [RegularExpression("[A-Z][A-Za-z0-9]*")]
		//    [StringLength(32)]
		//    public string Xyz { get; set; }
		internal sealed class ItemMetadata
		{

			// 元数据类不会实例化。
			private ItemMetadata()
			{
			}

			public EntityCollection<Composite> Composite
			{
				get;
				set;
			}

			public string Description
			{
				get;
				set;
			}

	
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int Durable
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int Effect
			{
				get;
				set;
			}

			public int Id
			{
				get;
				set;
			}

			public int Location
			{
				get;
				set;
			}

			public EntityCollection<Location> Locations
			{
				get;
				set;
			}

			public string Name
			{
				get;
				set;
			}

			public Skill Skill
			{
				get;
				set;
			}

			public Nullable<int> SkillId
			{
				get;
				set;
			}

			public string Type
			{
				get;
				set;
			}
		}
	}

	// MetadataTypeAttribute 将 LocationMetadata 标识为类
	//，以携带 Location 类的其他元数据。
	[MetadataTypeAttribute(typeof(Location.LocationMetadata))]
	public partial class Location
	{

		// 通过此类可将自定义特性附加到
		//Location 类的属性。
		//
		// 例如，下面的代码将 Xyz 属性标记为
		//必需属性并指定有效值的格式:
		//    [Required]
		//    [RegularExpression("[A-Z][A-Za-z0-9]*")]
		//    [StringLength(32)]
		//    public string Xyz { get; set; }
		internal sealed class LocationMetadata
		{

			// 元数据类不会实例化。
			private LocationMetadata()
			{
			}

			[Required]
			[RegularExpression("-1|0|1")]   //-1代表魔法，0代表无势力，1代表科学
			public string Attribution
			{
				get;
				set;
			}

			public string Building
			{
				get;
				set;
			}

			public EntityCollection<Event> Events
			{
				get;
				set;
			}

			public int Id
			{
				get;
				set;
			}

			public EntityCollection<Item> Items
			{
				get;
				set;
			}

			[Required]
			public string Name
			{
				get;
				set;
			}
		}
	}

	// MetadataTypeAttribute 将 PracticeMetadata 标识为类
	//，以携带 Practice 类的其他元数据。
	[MetadataTypeAttribute(typeof(Practice.PracticeMetadata))]
	public partial class Practice
	{

		// 通过此类可将自定义特性附加到
		//Practice 类的属性。
		//
		// 例如，下面的代码将 Xyz 属性标记为
		//必需属性并指定有效值的格式:
		//    [Required]
		//    [RegularExpression("[A-Z][A-Za-z0-9]*")]
		//    [StringLength(32)]
		//    public string Xyz { get; set; }
		internal sealed class PracticeMetadata
		{

			// 元数据类不会实例化。
			private PracticeMetadata()
			{
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int AmuletPractice
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int CastingPractice
			{
				get;
				set;
			}

			public int Id
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int MagicSwordPractice
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int ShootingPractice
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int SwordPractice
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int WandPractice
			{
				get;
				set;
			}
		}
	}

	// MetadataTypeAttribute 将 RoleMetadata 标识为类
	//，以携带 Role 类的其他元数据。
	[MetadataTypeAttribute(typeof(Role.RoleMetadata))]
	public partial class Role
	{

		// 通过此类可将自定义特性附加到
		//Role 类的属性。
		//
		// 例如，下面的代码将 Xyz 属性标记为
		//必需属性并指定有效值的格式:
		//    [Required]
		//    [RegularExpression("[A-Z][A-Za-z0-9]*")]
		//    [StringLength(32)]
		//    public string Xyz { get; set; }
		internal sealed class RoleMetadata
		{

			// 元数据类不会实例化。
			private RoleMetadata()
			{
			}

			public Item Accessories
			{
				get;
				set;
			}

			public Nullable<int> AccessoriesId
			{
				get;
				set;
			}

			[RegularExpression("^EX|^[ABCDES]")]
			[Required]
			public int Agility
			{
				get;
				set;
			}

			public Item Armor
			{
				get;
				set;
			}

			public Nullable<int> ArmorId
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int Attack
			{
				get;
				set;
			}

			public string Attitude
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int Contribution
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int Defense
			{
				get;
				set;
			}

			[RegularExpression("^EX|^[ABCDES]")]
			[Required]
			public int Endurance
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int Exp
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int Health
			{
				get;
				set;
			}

			public Item Helmet
			{
				get;
				set;
			}

			public Nullable<int> HelmetId
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int Hit
			{
				get;
				set;
			}

			public int Id
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int Kill
			{
				get;
				set;
			}

			[StringLength(30)]
			public string KillWord
			{
				get;
				set;
			}

			[StringLength(30)]
			public string LastWord
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int Level
			{
				get;
				set;
			}

			[RegularExpression("^EX|^[ABCDES]")]
			[Required]
			public int Magic
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int MagicAttack
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int MagicDefense
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int MaxHealth
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int MaxStrengthPower
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int Miss
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int Money
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int Move
			{
				get;
				set;
			}

			[Required]
			[StringLength(20)]
			[RegularExpression("[A-Z][A-Za-z0-9]*")]
			public string Name
			{
				get;
				set;
			}

			public EntityCollection<Item> PackageItems
			{
				get;
				set;
			}

			public Practice Practice
			{
				get;
				set;
			}

			public Item Shoe
			{
				get;
				set;
			}

			public Nullable<int> ShoeId
			{
				get;
				set;
			}

			public EntityCollection<Skill> Skills
			{
				get;
				set;
			}

			public string Status
			{
				get;
				set;
			}

			[RegularExpression("^EX|^[ABCDES]")]
			[Required]
			public int Strength
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int StrengthPower
			{
				get;
				set;
			}

			public int TitleId
			{
				get;
				set;
			}

			public Item Transport
			{
				get;
				set;
			}

			public Nullable<int> TransportId
			{
				get;
				set;
			}

			public Item Trump
			{
				get;
				set;
			}

			[RegularExpression("^EX|^[ABCDES]")]
			[Required]
			public int TrumpAbility
			{
				get;
				set;
			}

			public Nullable<int> TrumpId
			{
				get;
				set;
			}

			public User User
			{
				get;
				set;
			}

			public int UserId
			{
				get;
				set;
			}

			public Item Weapon
			{
				get;
				set;
			}

			public Nullable<int> WeaponId
			{
				get;
				set;
			}
		}
	}

	// MetadataTypeAttribute 将 SkillMetadata 标识为类
	//，以携带 Skill 类的其他元数据。
	[MetadataTypeAttribute(typeof(Skill.SkillMetadata))]
	public partial class Skill
	{

		// 通过此类可将自定义特性附加到
		//Skill 类的属性。
		//
		// 例如，下面的代码将 Xyz 属性标记为
		//必需属性并指定有效值的格式:
		//    [Required]
		//    [RegularExpression("[A-Z][A-Za-z0-9]*")]
		//    [StringLength(32)]
		//    public string Xyz { get; set; }
		internal sealed class SkillMetadata
		{

			// 元数据类不会实例化。
			private SkillMetadata()
			{
			}

			public string Description
			{
				get;
				set;
			}

			public int Id
			{
				get;
				set;
			}

			[Required]
			public string Name
			{
				get;
				set;
			}

			public EntityCollection<Role> Roles
			{
				get;
				set;
			}

			[Required]
			public string Type
			{
				get;
				set;
			}
		}
	}

	// MetadataTypeAttribute 将 UserMetadata 标识为类
	//，以携带 User 类的其他元数据。
	[MetadataTypeAttribute(typeof(User.UserMetadata))]
	public partial class User
	{

		// 通过此类可将自定义特性附加到
		//User 类的属性。
		//
		// 例如，下面的代码将 Xyz 属性标记为
		//必需属性并指定有效值的格式:
		//    [Required]
		//    [RegularExpression("[A-Z][A-Za-z0-9]*")]
		//    [StringLength(32)]
		//    public string Xyz { get; set; }
		internal sealed class UserMetadata
		{

			// 元数据类不会实例化。
			private UserMetadata()
			{
			}

			public EntityCollection<Achievement> Achievements
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^(?("")(""[^""]+?""@)|(([0-9a-zA-Z]((\.(?!\.))|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9a-zA-Z])@))" + @"(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9a-zA-Z][-\w]*[0-9a-zA-Z]\.)+[a-zA-Z]{2,6}))$")]
			public string Email
			{
				
				get;
				set;
			}

			public int Id
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int Money
			{
				
				get;
				set;
			}

			[Required]
			[StringLength(20)]
			[RegularExpression("[A-Z][A-Za-z0-9]*")]
			public string Name
			{
				
				get;
				set;
			}

			[Required]
			[StringLength(16)]
			public string Password
			{
				get;
				set;
			}

			public EntityCollection<Role> Roles
			{
				get;
				set;
			}

			[Required]
			[RegularExpression(@"^\+?[1-9][0-9]*$")]
			public int Score
			{
				get;
				set;
			}
		}
	}
}
